home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Interfaces & Libraries / Interfaces / PInterfaces / DatabaseAccess.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  11.0 KB  |  332 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        DatabaseAccess.p
  3.  
  4.      Contains:    Database Access Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT DatabaseAccess;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __DATABASEACCESS__}
  30. {$SETC __DATABASEACCESS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC DatabaseAccessIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __RESOURCES__}
  38. {$I Resources.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    MixedMode.p                                                    }
  43. {    Files.p                                                        }
  44. {        OSUtils.p                                                }
  45. {            Memory.p                                            }
  46. {        Finder.p                                                }
  47.  
  48. {$PUSH}
  49. {$ALIGN MAC68K}
  50. {$LibExport+}
  51.  
  52. CONST
  53.     typeNone                    = 'none';
  54.     typeDate                    = 'date';
  55.     typeTime                    = 'time';
  56.     typeTimeStamp                = 'tims';
  57.     typeDecimal                    = 'deci';
  58.     typeMoney                    = 'mone';
  59.     typeVChar                    = 'vcha';
  60.     typeVBin                    = 'vbin';
  61.     typeLChar                    = 'lcha';
  62.     typeLBin                    = 'lbin';
  63.     typeDiscard                    = 'disc';
  64. { "dummy" types for DBResultsToText }
  65.     typeUnknown                    = 'unkn';
  66.     typeColBreak                = 'colb';
  67.     typeRowBreak                = 'rowb';
  68. { pass this in to DBGetItem for any data type }
  69.     typeAnyType                    = 0;
  70.  
  71. { infinite timeout value for DBGetItem }
  72. { messages for status functions for DBStartQuery }
  73.     kDBUpdateWind                = 0;
  74.     kDBAboutToInit                = 1;
  75.     kDBInitComplete                = 2;
  76.     kDBSendComplete                = 3;
  77.     kDBExecComplete                = 4;
  78.     kDBStartQueryComplete        = 5;
  79.  
  80. { messages for status functions for DBGetQueryResults }
  81.     kDBGetItemComplete            = 6;
  82.     kDBGetQueryResultsComplete    = 7;
  83.     kDBWaitForever                = -1;
  84. {  flags for DBGetItem  }
  85.     kDBLastColFlag                = $0001;
  86.     kDBNullFlag                    = $0004;
  87.  
  88.     
  89. TYPE
  90.     DBType = OSType;
  91.  
  92.     DBAsyncParmBlkPtr = ^DBAsyncParamBlockRec;
  93.  
  94.     {
  95.         DBCompletionProcPtr uses register based parameters on the 68k and cannot
  96.         be written in or called from a high-level language without the help of
  97.         mixed mode or assembly glue.
  98.  
  99.         In:
  100.          => pb              A1.L
  101.     }
  102.     DBCompletionProcPtr = Register68kProcPtr;  { register PROCEDURE DBCompletion(pb: DBAsyncParmBlkPtr); }
  103.     DBCompletionUPP = UniversalProcPtr;
  104.  
  105.     DBAsyncParamBlockRec = RECORD
  106.         completionProc:            DBCompletionUPP;                        { pointer to completion routine }
  107.         result:                    OSErr;                                    { result of call }
  108.         userRef:                LONGINT;                                { for application's use }
  109.         ddevRef:                LONGINT;                                { for ddev's use }
  110.         reserved:                LONGINT;                                { for internal use }
  111.     END;
  112.  
  113. CONST
  114.     uppDBCompletionProcInfo = $0000B802; { Register PROCEDURE (4 bytes in A1); }
  115.  
  116. PROCEDURE CallDBCompletionProc(pb: DBAsyncParmBlkPtr; userRoutine: DBCompletionUPP);
  117.     {$IFC NOT GENERATINGCFM}
  118.     {To be implemented:  Glue to move parameters into registers.}
  119.     {$ENDC}
  120.  
  121. FUNCTION NewDBCompletionProc(userRoutine: DBCompletionProcPtr): DBCompletionUPP;
  122.     {$IFC NOT GENERATINGCFM }
  123.     INLINE $2E9F;
  124.     {$ENDC}
  125.  
  126. TYPE
  127.     ResListElem = RECORD
  128.         theType:                ResType;                                { resource type }
  129.         id:                        INTEGER;                                { resource id }
  130.     END;
  131.  
  132.     ResListPtr = ^ResListElem;
  133.     ResListHandle = ^ResListPtr;
  134.  
  135. { structure for query list in QueryRecord }
  136.     QueryArray = ARRAY [0..255] OF Handle;
  137.  
  138.     QueryListPtr = ^QueryArray;
  139.     QueryListHandle = ^QueryListPtr;
  140.  
  141.     QueryRecord = RECORD
  142.         version:                INTEGER;                                { version }
  143.         id:                        INTEGER;                                { id of 'qrsc' this came from }
  144.         queryProc:                Handle;                                    { handle to query def proc }
  145.         ddevName:                Str63;                                    { ddev name }
  146.         host:                    Str255;                                    { host name }
  147.         user:                    Str255;                                    { user name }
  148.         password:                Str255;                                    { password }
  149.         connStr:                Str255;                                    { connection string }
  150.         currQuery:                INTEGER;                                { index of current query }
  151.         numQueries:                INTEGER;                                { number of queries in list }
  152.         queryList:                QueryListHandle;                        { handle to array of handles to text }
  153.         numRes:                    INTEGER;                                { number of resources in list }
  154.         resList:                ResListHandle;                            { handle to array of resource list elements }
  155.         dataHandle:                Handle;                                    { for use by query def proc }
  156.         refCon:                    LONGINT;                                { for use by application }
  157.     END;
  158.  
  159.     QueryPtr = ^QueryRecord;
  160.     QueryHandle = ^QueryPtr;
  161.  
  162. { structure of column types array in ResultsRecord }
  163.     ColTypesArray = ARRAY [0..255] OF DBType;
  164.  
  165.     ColTypesPtr = ^ColTypesArray;
  166.     ColTypesHandle = ^ColTypesPtr;
  167.  
  168.     DBColInfoRecord = RECORD
  169.         len:                    INTEGER;
  170.         places:                    INTEGER;
  171.         flags:                    INTEGER;
  172.     END;
  173.  
  174.     ColInfoArray = ARRAY [0..255] OF DBColInfoRecord;
  175.  
  176.     ColInfoPtr = ^ColInfoArray;
  177.     ColInfoHandle = ^ColInfoPtr;
  178.  
  179.     ResultsRecord = RECORD
  180.         numRows:                INTEGER;                                { number of rows in result }
  181.         numCols:                INTEGER;                                { number of columns per row }
  182.         colTypes:                ColTypesHandle;                            { data type array }
  183.         colData:                Handle;                                    { actual results }
  184.         colInfo:                ColInfoHandle;                            { DBColInfoRecord array }
  185.     END;
  186.  
  187.     DBQueryDefProcPtr = ProcPtr;  { FUNCTION DBQueryDef(VAR sessID: LONGINT; query: QueryHandle): OSErr; }
  188.     DBStatusProcPtr = ProcPtr;  { FUNCTION DBStatus(message: INTEGER; result: OSErr; dataLen: INTEGER; dataPlaces: INTEGER; dataFlags: INTEGER; dataType: DBType; dataPtr: Ptr): BOOLEAN; }
  189.     DBResultHandlerProcPtr = ProcPtr;  { FUNCTION DBResultHandler(dataType: DBType; theLen: INTEGER; thePlaces: INTEGER; theFlags: INTEGER; theData: Ptr; theText: Handle): OSErr; }
  190.     DBQueryDefUPP = UniversalProcPtr;
  191.     DBStatusUPP = UniversalProcPtr;
  192.     DBResultHandlerUPP = UniversalProcPtr;
  193.  
  194. CONST
  195.     uppDBQueryDefProcInfo = $000003E0; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }
  196.     uppDBStatusProcInfo = $000FAA90; { FUNCTION (2 byte param, 2 byte param, 2 byte param, 2 byte param, 2 byte param, 4 byte param, 4 byte param): 1 byte result; }
  197.     uppDBResultHandlerProcInfo = $0003EAE0; { FUNCTION (4 byte param, 2 byte param, 2 byte param, 2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  198.  
  199. FUNCTION NewDBQueryDefProc(userRoutine: DBQueryDefProcPtr): DBQueryDefUPP;
  200.     {$IFC NOT GENERATINGCFM }
  201.     INLINE $2E9F;
  202.     {$ENDC}
  203.  
  204. FUNCTION NewDBStatusProc(userRoutine: DBStatusProcPtr): DBStatusUPP;
  205.     {$IFC NOT GENERATINGCFM }
  206.     INLINE $2E9F;
  207.     {$ENDC}
  208.  
  209. FUNCTION NewDBResultHandlerProc(userRoutine: DBResultHandlerProcPtr): DBResultHandlerUPP;
  210.     {$IFC NOT GENERATINGCFM }
  211.     INLINE $2E9F;
  212.     {$ENDC}
  213.  
  214. FUNCTION CallDBQueryDefProc(VAR sessID: LONGINT; query: QueryHandle; userRoutine: DBQueryDefUPP): OSErr;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $205F, $4E90;
  217.     {$ENDC}
  218.  
  219. FUNCTION CallDBStatusProc(message: INTEGER; result: OSErr; dataLen: INTEGER; dataPlaces: INTEGER; dataFlags: INTEGER; dataType: DBType; dataPtr: Ptr; userRoutine: DBStatusUPP): BOOLEAN;
  220.     {$IFC NOT GENERATINGCFM}
  221.     INLINE $205F, $4E90;
  222.     {$ENDC}
  223.  
  224. FUNCTION CallDBResultHandlerProc(dataType: DBType; theLen: INTEGER; thePlaces: INTEGER; theFlags: INTEGER; theData: Ptr; theText: Handle; userRoutine: DBResultHandlerUPP): OSErr;
  225.     {$IFC NOT GENERATINGCFM}
  226.     INLINE $205F, $4E90;
  227.     {$ENDC}
  228.  
  229. FUNCTION InitDBPack: OSErr;
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $3F3C, $0004, $303C, $0100, $A82F;
  232.     {$ENDC}
  233. FUNCTION DBInit(VAR sessID: LONGINT; ddevName: ConstStr63Param; host: ConstStr255Param; user: ConstStr255Param; passwd: ConstStr255Param; connStr: ConstStr255Param; asyncPB: DBAsyncParmBlkPtr): OSErr;
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $303C, $0E02, $A82F;
  236.     {$ENDC}
  237. FUNCTION DBEnd(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $303C, $0403, $A82F;
  240.     {$ENDC}
  241. FUNCTION DBGetConnInfo(sessID: LONGINT; sessNum: INTEGER; VAR returnedID: LONGINT; VAR version: LONGINT; VAR ddevName: Str63; VAR host: Str255; VAR user: Str255; VAR network: Str255; VAR connStr: Str255; VAR start: LONGINT; VAR state: OSErr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $303C, $1704, $A82F;
  244.     {$ENDC}
  245. FUNCTION DBGetSessionNum(sessID: LONGINT; VAR sessNum: INTEGER; asyncPB: DBAsyncParmBlkPtr): OSErr;
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $303C, $0605, $A82F;
  248.     {$ENDC}
  249. FUNCTION DBSend(sessID: LONGINT; text: Ptr; len: INTEGER; asyncPB: DBAsyncParmBlkPtr): OSErr;
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $303C, $0706, $A82F;
  252.     {$ENDC}
  253. FUNCTION DBSendItem(sessID: LONGINT; dataType: DBType; len: INTEGER; places: INTEGER; flags: INTEGER; buffer: UNIV Ptr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $303C, $0B07, $A82F;
  256.     {$ENDC}
  257. FUNCTION DBExec(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $303C, $0408, $A82F;
  260.     {$ENDC}
  261. FUNCTION DBState(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $303C, $0409, $A82F;
  264.     {$ENDC}
  265. FUNCTION DBGetErr(sessID: LONGINT; VAR err1: LONGINT; VAR err2: LONGINT; VAR item1: Str255; VAR item2: Str255; VAR errorMsg: Str255; asyncPB: DBAsyncParmBlkPtr): OSErr;
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $303C, $0E0A, $A82F;
  268.     {$ENDC}
  269. FUNCTION DBBreak(sessID: LONGINT; abort: BOOLEAN; asyncPB: DBAsyncParmBlkPtr): OSErr;
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $303C, $050B, $A82F;
  272.     {$ENDC}
  273. FUNCTION DBGetItem(sessID: LONGINT; timeout: LONGINT; VAR dataType: DBType; VAR len: INTEGER; VAR places: INTEGER; VAR flags: INTEGER; buffer: UNIV Ptr; asyncPB: DBAsyncParmBlkPtr): OSErr;
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $303C, $100C, $A82F;
  276.     {$ENDC}
  277. FUNCTION DBUnGetItem(sessID: LONGINT; asyncPB: DBAsyncParmBlkPtr): OSErr;
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $303C, $040D, $A82F;
  280.     {$ENDC}
  281. FUNCTION DBKill(asyncPB: DBAsyncParmBlkPtr): OSErr;
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $303C, $020E, $A82F;
  284.     {$ENDC}
  285. FUNCTION DBGetNewQuery(queryID: INTEGER; VAR query: QueryHandle): OSErr;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $303C, $030F, $A82F;
  288.     {$ENDC}
  289. FUNCTION DBDisposeQuery(query: QueryHandle): OSErr;
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $303C, $0210, $A82F;
  292.     {$ENDC}
  293. FUNCTION DBStartQuery(VAR sessID: LONGINT; query: QueryHandle; statusProc: DBStatusUPP; asyncPB: DBAsyncParmBlkPtr): OSErr;
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $303C, $0811, $A82F;
  296.     {$ENDC}
  297. FUNCTION DBGetQueryResults(sessID: LONGINT; VAR results: ResultsRecord; timeout: LONGINT; statusProc: DBStatusUPP; asyncPB: DBAsyncParmBlkPtr): OSErr;
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $303C, $0A12, $A82F;
  300.     {$ENDC}
  301. FUNCTION DBResultsToText(VAR results: ResultsRecord; VAR theText: Handle): OSErr;
  302.     {$IFC NOT GENERATINGCFM}
  303.     INLINE $303C, $0413, $A82F;
  304.     {$ENDC}
  305. FUNCTION DBInstallResultHandler(dataType: DBType; theHandler: DBResultHandlerUPP; isSysHandler: BOOLEAN): OSErr;
  306.     {$IFC NOT GENERATINGCFM}
  307.     INLINE $303C, $0514, $A82F;
  308.     {$ENDC}
  309. FUNCTION DBRemoveResultHandler(dataType: DBType): OSErr;
  310.     {$IFC NOT GENERATINGCFM}
  311.     INLINE $303C, $0215, $A82F;
  312.     {$ENDC}
  313. FUNCTION DBGetResultHandler(dataType: DBType; VAR theHandler: DBResultHandlerUPP; getSysHandler: BOOLEAN): OSErr;
  314.     {$IFC NOT GENERATINGCFM}
  315.     INLINE $303C, $0516, $A82F;
  316.     {$ENDC}
  317. FUNCTION DBIdle: OSErr;
  318.     {$IFC NOT GENERATINGCFM}
  319.     INLINE $303C, $00FF, $A82F;
  320.     {$ENDC}
  321.  
  322. {$ALIGN RESET}
  323. {$POP}
  324.  
  325. {$SETC UsingIncludes := DatabaseAccessIncludes}
  326.  
  327. {$ENDC} {__DATABASEACCESS__}
  328.  
  329. {$IFC NOT UsingIncludes}
  330.  END.
  331. {$ENDC}
  332.